The corridor map method: a general framework for real-time high-quality path planning

s for papers 0, 1, 2; Jerry Tromp, 3206750 The corridor map method: a general framework for real-time high-quality path planning Authors: Roland Geraerts and Mark Overmars A common problem in virtual interactive environments is to plan a path for one or several characters, and following that path from starting point to destination point. With the amount of processing currently available in our computers today, we manage to let graphics appear more and more realistic. With that amount of realism however, it is also more and more obvious if a character doesn’t behave in a realistic and natural way. Path planning is one of these issues that can cause unwanted odd and unrealistic behavior. Ideally we want smooth and natural looking paths, no unnecessary long paths, and we want the paths to be calculated as fast and as efficient as possible as we might want to have paths for dozens or hundreds of characters at the same time. Until recently, many of the techniques that were available to us have some of these properties, but not all. A* for example provides a shortest path, but the path is not natural, nor is it efficient to compute paths when doing it for a multiple of characters at the same time using a large input set. Potential field methods which direct the character through a potential field have a certain flexibility to avoid obstacles, but calculating the path is too slow to be applied in a virtual interactive environment. Probabilistic Roadmap Methods (PRM) are more efficient that potential field methods. A graph of the environment is constructed and Dijkstra’s shortest path algorithm can then be applied. However, paths are generally very ugly aesthetically, and although smoothing algorithms exist and are useful when dealing with a single character, doing path smoothing for more than one character is deemed too slow still. The corridor map method is a method for path planning which is described by the paper. Within this technique, the advantages of earlier methods are combined. It claims to provide a short, smooth and natural looking path, which is flexible towards obstacle avoidance and is fast in computing paths. It consists of two parts; an offline construction phase and an online query phase. In the offline phase, an input graph which serves as a skeleton for the corridors is first created, which has four important properties. The graph should be resolution complete (a valid query can always be connected to the graph), the graph should be small (which ensures low query times and low memory usage), the graph should contain useful cycles (which provide variations on global routes), and the graph provides high-clearance local paths (providing that the character always has the most freedom to move). The enhanced Reachability Roadmap Method provides such a graph, and will be used as an input graph. Each vertex in the graph represents a collision-free point, and every edge in the graph represents a local path. To construct the corridor map, clearance information is stored with the local paths in the input graph. This clearance information is represented by a union of largest empty balls centered around each (continuous) point on this local path. In the online query phase, we have to find a path for a character which connects its initial position to the goal position. The extraction of the path, which is calculated with Dijkstra’s shortest path algorithm, is called the backbone path. Together with the clearance information stored in the edges, they form a corridor, which guides the global motions of the character. The corridor is then extended to include the initial and goal position of the character. Finally, local motions of the character are guided by an attraction point, which moves along the backbone path from the start to the goal. The attraction point applies a force onto the character such that the character is attracted towards the attraction point. By using a model that is based on forces, the character can be easily influenced locally to avoid small and dynamic obstacles. This can be done by adding forces to the obstacles that repel the character when getting near. While this is a flexible way of avoiding dynamic obstacles, the result is that the shape of the path may be difficult to control and make future changes to the path (like shortening) hard. By creating a sub-corridor inside the corridor which excludes the dynamic obstacles, more freedom is obtained. The sub-corridor is modified where the obstacle intersects with the balls stored as clearance information on the local path. The point corresponding to the ball is moved away from the obstacle in a straight line, and the radius of the ball is adjusted. Shorter paths are created by introducing a second valid attraction point which moves in front of the first attraction point. The attraction point is valid if the character can be moved in a straight line to the attraction point without leaving the corridor. The time difference between the first and second attraction point can be varied, more time between both means a shorter path. However, increasing the time difference also causes computation time to increase. Enhancing Corridor Maps for Real-Time path Planning in Virtual Environments The second paper introduces some improvements to the original corridor map method, both to the construction phase and the query phase. For the construction phase there are several improvements. The initial method used an enhanced reachability roadmap as an input graph, but there are other graphs that have the same important properties. In the paper, Generalized Voronoi Diagrams are introduced. Computing the GVD can be done in two different ways. It can be computed exact, or approximated. Exact computations oppose challenges due to the algebraic complexity and high precision calculations required. Therefore, GVDs are often approximated. One of the promising methods for approximating a GVD is proposed in a paper by Hoff et al, in which graphics hardware is exploited to fasten computations. Information from the frame buffer and the Z-buffer is used to detect the boundaries of the GVD. The boundaries are traced to discover the vertices. Because of the discrete way this is done (i.e. using pixel coordinates), the concept of a discrete corridor is introduced, on contrary to the continuous corridor in the first paper. Because the method used also contributes some edges that are not part of the GVD, these have to be removed from the graph. Vertices with an out degree one are considered, their position in the frame buffer is determined. Neighboring pixels have different colors and correspond to different obstacles, so the distance from the point to these obstacles is determined and if it is the same, the vertex and its adjacent edge are removed. On a discrete corridor, a sample rate determines the amount of balls used on the local path. This sampling is important because it determines the coverage of the free space the character can travel in. The number of samples is determined by the distance between balls; a distance of zero would give a continuous corridor, but that is not practical. A lower bound on this distance is therefore set to the width of a pixel. An upper bound is also needed in order to find a path, which depends on the distance and radius of two consecutive balls and the radius of the character. The radius of the next ball should be smaller than or equal to the distance between the previous and the next ball and the radius of the character. When this relation holds, the discrete corridor is called an r-Valid Discrete Corridor. Each corridor in the graph is resampled to be an r-Valid discrete corridor. Last, some information is added to elements of the corridor map to speed up querying time in the querying phase. First, for each vertex the connected components are identified to allow quick checks whether two vertices can be connected by a path. Second, for each corridor the largest radius a character can have is calculated to speed up finding the shortest backbone path. In the query phase four steps have to be performed in order to find a path. First, a closest ball to the character has to be found. This can be done by checking each ball of each corridor taking linear time in the number of balls. This might be expensive especially with larger maps, so in order to fasten this a kd-tree is used of which the dividing lines separate two non-overlapping sets of balls. Balls that intersect are stored in an interval tree, which are stored at each node in the kd-tree. The intervals correspond to the segment of the dividing line whose endpoint intersect with the bounding box of the ball. Query time is thus improved to O(k + logn) time. For each reported ball its checked if it encloses the ball of the character, and from all balls that enclose the ball that is the closest to the character is computed. The second step is finding the shortest backbone path. Because information on corridor width has already been computed in construction time it can be determined in constant time if a local corridor is valid for the character to travel through. Finding the backbone path is done using either Dijkstra’s algorithm or preferably A*. The third step is computing the corridor. This is done by taking the shortest backbone path and taking the radii of the balls on the edges of the path. The last edge towards the goal doesn’t have this information so it should be created, of course the placements of the balls on the last edge has to be r-valid. Last step is computing the path. Recall that forces are used to make the character accelerate. Iteratively applying the Verlet integration scheme while updating the character its position until the character is near the goal position obtains the final path. Planning Shortest Paths with Clearance using Explicit Corridors The previous two papers discussed the corridor map method and some improvements on the method. However, one feature of path planning algorithms is that of the shortest path. A* for example always yields the shortest path at the expense of unnatural looking paths where the character might get too close to an obstacle. This paper discusses a method on improving the current corridor map method to include shortest paths by introducing explicit corridors. To make paths aesthetically pleasing, a certain clearance is calculated around the obstacle. Until now we’ve only seen implicit corridors, corridors of which the representation isn’t covering the whole of free space because of its discrete nature. Increasing the sample rate on the discs would also increase the coverage of free space, but at the cost of the efficiency of the algorithm. Also, several operations on the implicit corridor used by algorithms used for obstacle avoidance, path variation, character avoidance and others may have to use non local information (i.e. a non-constant amount of discs) which also degrade the efficiency of the algorithm. This can be solved if the operations can be made local and thus efficient if the boundaries of the corridor can be computed. For each disc a left and a right closest point to the nearest obstacles should be stored, which then yields the explicit corridor. Computing the closest points is done using pixel data from the frame buffer, and applying simple linear algebra, all in constant time. Next is shown how the boundary of the corridor can be computed. Three parts are identified, a start section, a middle section and an end section. While the start and end section are generally arcs that go from the left to the right closest point around the center of the disc, the middle section can be a concatenation of different types of arcs. Two discs of incident edges could have been concatenated, so they share centers. They can however have different closest (right) points. In that case the right boundary is a circular arc, and the left boundary is a degenerated arc that is a single point. When connecting closest points from two adjacent discs on the same edge, they trace part of an obstacle. Storing the trace itself would make the description of the boundary more complex, so its chosen to connect those two points by a line segment and store that instead. This line segment however may intersect the obstacle. This is solved later as the intersection depth can be made arbitrarily small. Because the closest points can be computed in constant time, the boundary of the corridor can be constructed in linear time in the number of discs. Shown is that for any point p in the corridor can be computed easily, which allows the computation of the clearance between the character and the obstacles. To solve problems with the boundary of the corridor intersecting the obstacles, an error metric is proposed which states the maximum intersection depth. Shown is how this error is smaller than the distance between two discs, such that it can easily be controlled by adding more discs. Next the actual calculation of the error is shown. Now that the explicit corridor is well defined, it is easy to adjust the corridor to accommodate a minimum clearance to the obstacles. This is done by moving the closest points over the segment that connects the closest point to the center of its corresponding disc by a clearance metric. This shrinking of the corridor results in a shrunk corridor. Again an error metric is introduced to resolve unwanted complexities. Finally, a shortest path can be calculated by regarding the corridor as a polygon and using triangulation and its dual graph to determine which diagonals are crossed, according to Guibas et al. The same algorithm can be applied to shrunk corridors.